
/*
 * 
 *版本号:1.1.9
 * 
 * 
 * 
 * 
 */





let isAccessibilityEnabled = () => {
    let accessibilityManager = context.getSystemService(android.content.Context.ACCESSIBILITY_SERVICE);
    // 获取已启用的无障碍服务列表
    let enabledServices = accessibilityManager.getEnabledAccessibilityServiceList(android.accessibilityservice.AccessibilityServiceInfo.FEEDBACK_GENERIC);
    // 遍历已启用的无障碍服务列表
    for (let i = 0; i < enabledServices.size(); i++) {
        let service = enabledServices.get(i);
        if (service.getId().startsWith(context.getPackageName())) {
            return true;
        }
    }
}
log('无障碍服务', isAccessibilityEnabled())

if (!click(1, 1)) {
    powerDialog();
    exit()
}

// 获取设备的宽度和高度
var x = device.width;
var y = device.height;

// 打印设备的宽度和高度
log("设备宽度:", x);
log("设备高度:", y);


device.setBrightnessMode(0); // 设置亮度模式为手动
device.setNotificationVolume(0) // 设置通知音量为 0
device.setMusicVolume(0) // 设置媒体音量为 0


function Videos() {

    this.jk = null
    this.xfc = null

    this.heart = 0; // 定义初始心跳值
    this.heartID = null
    this.lodHeart = -1; // 记录上一次的心跳值
    this.running = false; // 控制主程序循环的标志



    this.user_apiUrl = 'http://124.223.4.225:3000/api/users'
    this.phone_apiUrl = 'http://124.223.4.225:3001/api/devices'

    // 初始化对话历史
    this.conversationHistory = [];
    this.品牌 = device.brand
    this.型号 = device.model
    this.IMEI = device.getIMEI()

    this.config = this.下载配置文件()
    this.手机列表 = this.查询所有数据(this.phone_apiUrl)
    this.当前手机数据 = this.查询手机数据()



    this.手机号 = this.获取本机号码()
    this.添加手机()
    this.初始化任务.call(this, "美女", "美女");
    this.初始化任务.call(this, "创业", "创业");


    if (!this.run) {
        toastLog("该任务已关闭")
        exit()
    }

    //评论区---------------------------------------------------


    this.评论图标id = id("c5t")
    this.评论条数id = id("c4b")
    this.关闭评论区X = desc("关闭")
    this.评论区最大化id = id("h11")
    this.点击进入直播间 = text("点击进入直播间")
    this.主页用户昵称 = descContains("，复制名字")
    this.用户年龄 = descEndsWith("岁")
    this.男用户 = descStartsWith("男")
    this.女用户 = descStartsWith("女")
    this.用户区域 = textStartsWith("IP:")
    this.用户ID = textStartsWith("抖音号:")


    this.主页右上角三个点 = desc("更多")
    this.评论区展开id = id("z5m").text("展开")
    this.返回按钮 = desc("返回")
    this.私信页返回按钮 = descContains("返回")
    this.视频页私信按钮 = id("uz8") //找到这个按钮说明视频是是好友视频，跳过
    this.视频页关注加号 = id("hpe")

    // 初始化评论区相关的变量
    this.评论区id = id("g+6");
    this.评论id = id("dsc");
    this.评论区用户头像desc = descEndsWith("的头像")
    this.评论区用户昵称id = id("title");
    this.评论区用户时间id = id("c9s");
    this.评论区用户地区id = id("c58");
    this.评论区用户评论id = id("content");
    this.评论区用户点赞id = id("er1");
    this.评论区用户点赞状态id = id("ero");
    this.评论区展开按钮id = id("hoz")

    //首页---------------------------------------------------
    this.首页消息按钮text = text("消息")
    this.评论按钮id = id("c5t")
    this.视频主昵称id = id("title")
    this.视频标题id = id("desc")
    this.展开内容id = id("e4s")
    this.首页我按钮desc = desc('我，按钮')
    this.主页更多desc = desc('更多')
    this.主页更多功能页面text = text("更多功能")


    this.主页搜索按钮desc = descStartsWith("搜索")
    this.搜索按钮text = text("搜索")

    this.搜索页视频按钮text = text("视频")
    this.搜索页视频id = id("ti=")

    // 同城---------------------------------------------------
    this.同城 = id("z5+")

    //消息页---------------------------------------------------
    this.消息页顶部心id = id("kqf")
    this.消息页粉丝信息数量 = id("su7")
    this.消息页底部新消息数量id = id("wj+")
    this.消息页新朋友text = text("新朋友")
    this.消息页新朋友页头像id = id("jih")
    this.消息页新朋友页按钮id = id("j+8")
    this.私信页顶部头像 = id("ang")


    //我的个人主页
    this.发私信页面text = text("发私信")
    this.主页作品id = id("nqn")
    this.主页我的钱包text = text("我的钱包")
    this.主页粉丝text = text("粉丝")
    this.主页关注text = text("关注")
    this.主页粉丝页粉丝头像 = descEndsWith("头像")

    this.主页粉丝页粉丝昵称 = null
    this.主页粉丝页粉丝关注按钮 = null
    this.主页粉丝页粉丝三个点 = null

    this.data = {};
    this.临时列表 = new Set();   //储存已经处理过的用户名
    this.check_list = ["抖音 想访问你的通讯录", "拒绝"] //弹出窗口列表
    this.search_temp = [] //储存搜索过的关键字
    this.lastLikeTime = 0 //上次点赞时间
}

Videos.prototype.清理缓存 = function () {
    log("清理缓存")
    this.打开抖音()
    this.首页消息按钮text.waitFor();
    this.slp(3000)
    click(this.首页我按钮desc.findOne().bounds().centerX(), this.首页我按钮desc.findOne().bounds().centerY())
    this.主页更多desc.findOne().click()
    this.主页更多功能页面text.waitFor()
    click("设置")
    click("清理缓存")
    this.slp(2000)
    click("清理")
    this.slp(2000)
    if (id("im8").exists()) {
        this.slp(2000)
        click("清理")
        this.slp(2000)
        click("清理")
    }
    this.slp(2000)
}
Videos.prototype.获取本机号码 = function () {
    // 获取 TelephonyManager 服务
    var mTelephonyManager = context.getSystemService(context.TELEPHONY_SERVICE);
    // 尝试获取电话号码
    var phoneNumber = mTelephonyManager.getLine1Number();
    // 检查电话号码是否获取成功
    if (phoneNumber === null || phoneNumber === "") {
        // 如果获取失败，返回 null
        return null;
    }
    // 去掉前面的 + 号
    if (phoneNumber.startsWith("+86")) {
        phoneNumber = phoneNumber.substring(3);
    }
    // 返回处理后的电话号码
    return phoneNumber;
}
Videos.prototype.监控 = function () {
    log("监控线程启动")
    function checkConditions() {
        if (text("举报").exists()) { back() }
        if (text("相关推荐").exists()) { back() }
        if (text("默认打开").exists()) { back() }
        if (text("聊天智能推荐").exists()) {
            back()
            sleep(1000)
            back()
        }
        if (desc("更多朋友 按钮").exists()) { back() }
        if (text("抖音 想访问你的通讯录").exists()) { click("拒绝") }
        if (textContains("访问地理位置信息权限说明").exists()) { click("取消") }
        if (text("满意").exists()) { click("满意") }
        if (textContains("将卸载此应用程序").exists()) { click("取消") }
        if (text("不再提醒").exists()) { click("不再提醒") }
        if (text("欢迎体验新版本").exists()) { click("以后再说") }
        if (text("仅充电").exists()) { click("仅充电") }
        if (text("减少此类型").exists()) {
            click("减少此类型")
            this.slp(2000)
            back()
        }
        if (text("系统更新").exists()) {
            click("稍后")
            this.slp(2000)
        }
        if (text("去汽水听我的精选歌单").exists()) { this.返回按钮.click() }
    }
    checkConditions()
    // 使用 setInterval 每秒调用一次 checkConditions
    const intervalId = setInterval(checkConditions, 10000);
}
Videos.prototype.判断评论区时间 = function () {
    // log("评论区用户回复时间:", this.评论区用户回复时间)
    const date1 = new Date(this.评论区用户回复时间);
    // 获取当前日期
    const currentDate = new Date();
    // 计算两个日期之间的时间差（以毫秒为单位）
    const timeDifference = currentDate - date1;
    // 将时间差转换为天数
    const dayDifference = timeDifference / (1000 * 60 * 60 * 24);
    // 判断差值是否大于7天
    return dayDifference > this.config.set_talk_time;
}
Videos.prototype.悬浮窗 = function () {
    颜色 = "#88000000"
    宽度 = 200
    高度 = 300
    let win = floaty.rawWindow(
        <vertical>
            <com.stardust.autojs.core.console.ConsoleView id="console" h="{{高度}}" w="{{宽度}}" bg="{{颜色}}" />
        </vertical>
    );
    //悬浮穿透
    win.setTouchable(false);
    //悬浮移动
    win.setPosition(0, 150);
    //时钟死循环
    setInterval(() => { }, 1000);
    //去除控制台按钮
    //win.console.setInputEnabled(true);
    //加载日志信息到ui控制台
    win.console.setConsole(runtime.console);

}
Videos.prototype.下载配置文件 = function () {
    const apiUrl = 'https://gitee.com/liang_shanshui/dytalk/raw/master'; // 确保这个 URL 是正确的
    const configUrl = `${apiUrl}/config.json`; // 构建请求的 URL

    // 发送 GET 请求读取 config.json
    const response = http.get(configUrl); // 使用 http.get 发送请求
    // log(`请求的 URL: ${configUrl}`); // 打印请求的 URL
    // log(`响应状态码: ${response.statusCode}`); // 打印响应状态码

    // 检查响应状态码
    if (response.statusCode === 200) {
        const configData = JSON.parse(response.body.string()); // 读取响应体并解析为 JSON
        return configData; // 直接返回配置对象
    } else {
        console.error('无法读取配置文件，状态码:', response.statusCode); // 打印错误信息
        console.error('响应内容:', response.body); // 打印响应内容以获取更多信息
        return null; // 如果状态码不是 200，返回 null
    }
}
Videos.prototype.打开抖音 = function () {
    log('执行打开抖音')
    this.heart++
    this.关闭抖音()

    // app.launchApp("抖音")
    click("抖音")
    this.评论图标id.waitFor()
    this.slp(3000)
    while (true) {
        if (this.评论图标id.exists()) {
            log('找到评论图标')
            this.slp(3000)
            break
        }
        click("首页")
        this.slp(7000)
    }
    this.slp(1000)
}
Videos.prototype.查询包名 = function () {
    function getInstalledApps() {
        let packageManager = context.getPackageManager();
        let packages = packageManager.getInstalledApplications(0);
        let appList = [];
        for (let i = 0; i < packages.size(); i++) {
            let appInfo = packages.get(i)
            appList.push({
                name: appInfo.loadLabel(packageManager).toString(),
                packageName: appInfo.packageName
            });
        }
        return appList
    }

    // 示例使用
    let installedApps = getInstalledApps();
    installedApps.forEach(app => {
        if (app.name === "抖音") {
            return app.packageName
        }

    })
}
Videos.prototype.关闭抖音 = function () {
    log('执行关闭抖音');
    let packageName = "com.ss.android.ugc.aweme";
    let maxRetries = 7; // 最大重试次数
    let attempts = 0; // 当前尝试次数
    let closedSuccessfully = false; // 关闭状态标志

    while (attempts < maxRetries && !closedSuccessfully) {
        log(`尝试第 ${attempts + 1} 次关闭抖音`);
        sleep(2000); // 等待时间

        // 尝试打开应用设置
        app.openAppSetting(packageName);
        sleep(2000); // 等待设置页面加载

        // 检查设置页面是否成功打开
        if (text("强行停止").exists()) {
            log("设置页面已打开");
            var stops = text("强行停止").findOne();
            if (stops.enabled()) {
                log("强行停止");
                stops.click();
                sleep(2000); // 等待强行停止操作完成
                // 检查是否出现确认对话框
                if (text("确定").exists()) {
                    text("确定").click();
                    closedSuccessfully = true; // 设置成功关闭标志
                    log("抖音应用已成功关闭");

                } else if (text("强行停止").exists()) {
                    text("强行停止").click()
                    closedSuccessfully = true; // 设置成功关闭标志
                    log("抖音应用已成功关闭");

                } else {
                    log("未找到确认按钮，继续尝试");
                }
            } else {
                closedSuccessfully = true; // 设置成功关闭标志
                log("强行停止按钮不可用，退出设置页面");

            }
        } else {
            log("设置页面未打开，继续尝试");
        }

        attempts++; // 增加尝试次数
        sleep(2000); // 等待时间，避免过快重试
    }

    if (!closedSuccessfully) {
        log("达到最大重试次数，未能成功关闭抖音应用");
    }

    sleep(2000);
    home(); // 返回主屏幕
    sleep(2000);
    log(app.getAppName(packageName) + "已关闭");
}
Videos.prototype.关闭评论 = function () {
    this.关闭评论区X.waitFor()
    this.slp(1000)
    if (this.关闭评论区X.exists()) {
        log('找到关闭评论区X')
        this.关闭评论区X.click()
    }
}
Videos.prototype.获取视频时长 = function () {
    // 直接使用 this.video_time 来存储转换后的秒数
    this.video_time = 5; // 初始化 video_time
    const progressBar = id("08b").findOnce();
    const duration = 3000; // 设置线程运行时间为3秒

    if (progressBar) {
        // 获取进度条的边界
        const left = progressBar.bounds().left;   // 进度条左边界
        const right = progressBar.bounds().right; // 进度条右边界
        const top = progressBar.bounds().top;     // 进度条上边界

        // 计算滑动的目标位置
        const x1 = left + 1;   // 起始 x 坐标
        const y1 = top + 1;    // 起始 y 坐标
        const x2 = right * 0.2;   // 结束 x 坐标
        const y2 = top + 1;     // 结束 y 坐标

        // 启动一个线程来查找时间控件
        const findTimeControlThread = threads.start(() => {
            const startTime = new Date().getTime(); // 记录开始时间
            while (new Date().getTime() - startTime < duration) {
                if (id("xqu").exists()) {
                    const timeString = id("xqu").findOne().text(); // 获取时间字符串
                    this.video_time = convertToSeconds(timeString); // 直接赋值给 this.video_time
                    log("视频实际时长:", this.video_time);

                    // 根据条件调整 video_time
                    if (this.video_time > 30) {
                        this.video_time = (30 + random(3, 7)) * 1000;
                    } else if (this.video_time < 10) {
                        this.video_time = (this.video_time * random(2, 3)) * 1000;
                    } else {
                        this.video_time = (this.video_time + random(3, 7)) * 1000;
                    }
                    log("调整后视频停留时间:", this.video_time / 1000, "秒");

                    break; // 找到后退出循环
                }
                // log("未找到时间控件，继续查找...");
                sleep(200); // 每200毫秒查找一次
            }
        });

        // 启动一个线程来执行滑动操作
        const swipeThread = threads.start(() => {
            log("滑动进度条");
            swipe(x1, y1, x2, y2, duration);
        });

        // 等待两个线程完成
        findTimeControlThread.join();
        swipeThread.join();
    }

    // 内部函数:将时间字符串转换为总秒数
    function convertToSeconds(timeStr) {
        const timeParts = timeStr.split(":"); // 使用冒号分割字符串
        let times = 0; // 声明 times 变量

        if (timeParts.length === 3) {
            // 如果是时:分:秒格式
            let hos = parseInt(timeParts[0], 10); // 获取小时
            let mins = parseInt(timeParts[1], 10); // 获取分钟
            let secs = parseInt(timeParts[2], 10); // 获取秒
            times = hos * 3600 + mins * 60 + secs; // 计算总秒数
        } else if (timeParts.length === 2) {
            // 如果是分:秒格式
            let mins = parseInt(timeParts[0], 10); // 获取分钟
            let secs = parseInt(timeParts[1], 10); // 获取秒
            times = mins * 60 + secs; // 计算总秒数
        }

        return times; // 返回计算的总秒数
    }

    // 由于 this.video_time 是在线程中设置的，可能在返回时还未更新
    return this.video_time; // 返回 video_time
}
Videos.prototype.获取主页用户昵称 = function () {
    if (this.主页用户昵称.exists()) {
        // log(this.主页用户昵称.findOne().text())
        return this.主页用户昵称.findOne().text()
    }
}
Videos.prototype.获取用户年龄 = function () {
    if (this.用户年龄.exists()) {
        // log(this.用户年龄.findOne().text())
        return parseInt(this.用户年龄.findOne().text().replace("岁", ""))
    } else {
        // log("无年龄")
        return (0)
    }
}
Videos.prototype.获取用户性别 = function () {

    if (this.男用户.exists()) {
        // log("男")
        return ("男")
    }
    if (this.女用户.exists()) {
        // log("女")
        return ("女")
    }
    // log("无性别")
    return ("无")
}
Videos.prototype.获取用户区域 = function () {
    if (this.用户区域.exists()) {
        // log(this.用户区域.findOne().text())
        return this.用户区域.findOne().text().replace("IP:", "")
    }
}
Videos.prototype.获取用户ID = function () {
    if (this.用户ID.exists()) {
        // log(this.用户ID.findOne().text())
        return this.用户ID.findOne().text().replace("抖音号:", "")
    }
}
Videos.prototype.收集用户数据 = function () {
    // 收集数据并存储到 this.data
    this.data = {
        user_name: this.获取主页用户昵称() || "无",
        user_age: this.获取用户年龄() || 0,
        user_sex: this.获取用户性别() || "无",
        user_ip: this.获取用户区域() || "无",
        user_id: this.获取用户ID() || "无",
    };

    // 打印收集到的数据
    // log("收集到的数据:", JSON.stringify(this.data));
}
Videos.prototype.查询用户数据 = function (user_id) {
    if (user_id) {
        // 发送 GET 请求查询用户，使用查询参数
        const response = http.get(`${this.user_apiUrl}/search?user_id=${user_id}`);
        // log(`请求的 URL: ${this.user_apiUrl}/search?user_id=${user_id}`); // 打印请求的 URL
        // log(`响应状态码: ${response.statusCode}`); // 打印响应状态码

        // 检查响应状态码
        if (response.statusCode === 200) {
            const userData = JSON.parse(response.body.string()); // 读取响应体并解析为 JSON
            // log('查询到的用户:', userData); // 使用存储的内容

            // 判断返回的数据是否为空列表
            if (Array.isArray(userData) && userData.length === 0) {
                // console.warn('用户列表为空'); // 打印警告信息
                return null; // 返回 null 或者其他处理逻辑
            }

            return userData; // 返回用户信息
        } else {
            console.error('没有找到用户，状态码:', response.statusCode); // 打印错误信息
            console.error('响应内容:', response.body); // 打印响应内容以获取更多信息
            return null; // 如果状态码不是 200，返回 null
        }
    } else {
        console.warn('没有提供 user_id'); // 打印警告信息
        return null; // 如果没有提供 user_id，返回 null
    }
}
Videos.prototype.写入数据 = function (url, data) {
    return new Promise((resolve, reject) => {
        http.postJson(url, data, {
            headers: {
                "Content-Type": "application/json"
            }
        }, function (response) {
            // 判断状态码
            if (response.statusCode === 201) {
                log("数据添加成功，状态码:", response.statusCode); // 打印状态码 201
                resolve(true); // 解析成功，返回 true
            } else {
                console.error("添加数据失败，状态码:", response.statusCode); // 打印失败状态码
                reject(new Error("请求失败，状态码: " + response.statusCode)); // 请求失败
            }
        });
    });
}
Videos.prototype.查询所有数据 = function (url) {
    const response = http.get(`${url}`);
    if (response.statusCode === 200) {
        const phoneData = JSON.parse(response.body.string()); // 读取响应体并解析为 JSON
        if (Array.isArray(phoneData) && phoneData.length === 0) {
            // console.warn('列表为空'); // 打印警告信息
            return []; // 返回空数组
        }
        return phoneData; // 返回信息
    } else {
        console.error('查询所有数据失败，状态码:', response.statusCode); // 打印错误信息
        console.error('响应内容:', response.body); // 打印响应内容以获取更多信息
        return null; // 如果状态码不是 200，返回 null
    }
}
Videos.prototype.查询手机数据 = function () {
    // console.log(`查询 IMEI: ${this.IMEI}`); // 打印 IMEI
    if (this.IMEI) {
        // 检查 IMEI 格式
        if (!/^\d{15}$/.test(this.IMEI)) {
            console.warn('无效的 IMEI 格式'); // 打印警告信息
            return null; // 返回 null 或其他处理逻辑
        }
        // 发送 GET 请求查询手机数据，使用查询参数
        const response = http.get(`${this.phone_apiUrl}/search?IMEI=${this.IMEI}`);

        // 检查响应状态码
        if (response.statusCode === 200) {
            const phoneData = JSON.parse(response.body.string()); // 读取响应体并解析为 JSON

            // 判断返回的数据是否为空列表
            if (Array.isArray(phoneData) && phoneData.length === 0) {
                console.warn('手机数据列表为空'); // 打印警告信息
                return null; // 返回 null 或者其他处理逻辑
            }
            // log(phoneData)
            return phoneData; // 返回手机信息
        } else {
            console.error('没有找到手机数据，状态码:', response.statusCode); // 打印错误信息
            console.error('响应内容:', response.body); // 打印响应内容以获取更多信息
            return null; // 如果状态码不是 200，返回 null
        }
    } else {
        console.warn('没有提供 IMEI'); // 打印警告信息
        return null; // 如果没有提供 IMEI，返回 null
    }
}
Videos.prototype.更新手机数据 = function (updateData) {
    // 构建请求 URL
    const url = `${this.phone_apiUrl}/updateByIMEI`;

    // 构建请求体
    const requestBody = {};

    // 仅添加需要更新的字段
    if (updateData.IMEI !== undefined) {
        requestBody.IMEI = updateData.IMEI; // 始终需要提供 IMEI
    }
    if (updateData.访问时间 !== undefined) {
        requestBody.访问时间 = updateData.访问时间;
    }
    if (updateData.手机号 !== undefined) {
        requestBody.手机号 = updateData.手机号;
    }
    if (updateData.已关注数量 !== undefined) {
        requestBody.已关注数量 = updateData.已关注数量;
    }
    if (updateData.评论赞数量 !== undefined) {
        requestBody.评论赞数量 = updateData.评论赞数量;
    }
    if (updateData.视频赞数量 !== undefined) {
        requestBody.视频赞数量 = updateData.视频赞数量;
    }
    if (updateData.私信数量 !== undefined) {
        requestBody.私信数量 = updateData.私信数量;
    }
    if (updateData.任务 !== undefined) {
        requestBody.任务 = updateData.任务;
    }

    // 发送 POST 请求更新设备数据
    http.postJson(url, requestBody, {
        headers: {
            "Content-Type": "application/json"
        }
    }, function (response) {
        // 判断状态码
        if (response.statusCode === 200) {
            // console.log("设备数据更新成功，状态码:", response.statusCode); // 打印成功状态码
        } else {
            console.error("更新设备数据失败，状态码:", response.statusCode); // 打印失败状态码
            console.error("响应内容:", response.body); // 打印响应内容以获取更多信息
        }
    });
}
Videos.prototype.初始化任务 = function (taskName, phoneType) {
    // 查询当前手机的任务
    this.当前手机任务 = this.查询手机数据()[0].任务;
    log(`当前手机任务:${this.当前手机任务}`);

    // 已分配任务手机数量
    const 已分配任务手机 = this.手机列表.filter(item => item.任务 === taskName);
    const 当前任务手机数量 = 已分配任务手机.length;

    // 情况 1: 当前手机任务为 null
    if (this.当前手机任务 == null) {
        // 检查已分配任务手机数量是否小于限制
        if (当前任务手机数量 < this.config.work[phoneType].phone_num) {
            // 为当前手机分配任务
            this.设置任务(phoneType);
            this.phone_data = {
                "IMEI": this.IMEI,
                "访问时间": this.获取时间(),
                "手机号": this.手机号,
                "任务": taskName
            };
            this.更新手机数据(this.phone_data);
            console.log(`手机 ${this.IMEI} 已成功分配任务 ${taskName}。`);
        } else {
            console.log(`手机 ${this.IMEI} 无法分配任务 ${taskName}，已分配任务手机数量已满。`);
        }
    }
    // 情况 2: 当前手机任务与 taskName 相同
    else if (this.当前手机任务 === taskName) {
        // 更新访问时间
        this.设置任务(phoneType);
        this.phone_data = {
            "IMEI": this.IMEI,
            "访问时间": this.获取时间(),
            "手机号": this.手机号,
            "任务": taskName
        };
        this.更新手机数据(this.phone_data);
        console.log(`手机 ${this.IMEI} 状态已更新`);
    }
}
Videos.prototype.设置任务 = function (phoneType) {
    this.run = this.config.work[phoneType].run;//任务开关
    this.search_keywords = this.config.work[phoneType].search_keywords;//标题关键字
    this.reply_keywords = this.config.work[phoneType].reply_keywords; //回复关键字
    this.contexts = this.config.work[phoneType].contexts.join("\n"); //gpt提示词
    this.phone = this.config.work[phoneType].phone;//联系方式
    this.sex = this.config.work[phoneType].sex;//性别
    this.age = this.config.work[phoneType].age;//年龄
    this.city_in = this.config.work[phoneType].city_in;//放行城市
    this.city_out = this.config.work[phoneType].city_out;//拦截城市
    this.city_set = this.config.work[phoneType].city_set;//同城
    this.about_friends = this.config.work[phoneType].about_friends;//关注好友数量

}
Videos.prototype.添加手机 = function () {
    // log(`添加手机 ${this.IMEI} 到手机列表`)
    // 查询手机数据，检查是否存在该 IMEI
    if (!this.当前手机数据) {
        log(this.获取时间())
        // 写入手机数据，包含 IMEI 和当前时间戳
        this.phone_data = {
            "品牌": this.品牌,
            "型号": this.型号,
            "IMEI": this.IMEI,
            "访问时间": this.获取时间() // 添加访问时间字段
        };
        this.写入数据(this.phone_apiUrl, this.phone_data)
        console.log(`IMEI ${this.IMEI} 已添加`);
    }
}
Videos.prototype.获取时间 = function () {
    // 创建 Date 对象
    const date = new Date(Date.now());
    // 提取年、月、日、时、分、秒
    const year = date.getFullYear(); // 获取年份
    const month = String(date.getMonth() + 1).padStart(2, '0'); // 获取月份（注意:月份从0开始，所以要加1）
    const day = String(date.getDate()).padStart(2, '0'); // 获取日期
    const hours = String(date.getHours()).padStart(2, '0'); // 获取小时
    const minutes = String(date.getMinutes()).padStart(2, '0'); // 获取分钟
    const seconds = String(date.getSeconds()).padStart(2, '0'); // 获取秒
    // 格式化为 YYYY-MM-DD HH:mm:ss
    const formattedDate = `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;

    return formattedDate;
}
Videos.prototype.下滑 = function () {
    this.滑动(x / 2, y / 2, x / 2, y - 500)
}
Videos.prototype.上滑 = function () {
    log("上滑")
    this.滑动(x / 2, y * 0.7, x / 2, y * 0.2)
}
Videos.prototype.滑动 = function (sx, sy, ex, ey) {
    // log(sx, sy, ex, ey)
    function bezierCreate(x1, y1, x2, y2, x3, y3, x4, y4) {
        var h = 50;
        var cp = [{ x: x1, y: y1 + h }, { x: x2, y: y2 + h }, { x: x3, y: y3 + h }, { x: x4, y: y4 + h }];
        var numberOfPoints = 20;
        var curve = [];

        var dt = 1.0 / (numberOfPoints - 1);
        for (var i = 0; i < numberOfPoints; i++) {
            var ax, bx, cx;
            var ay, by, cy;
            var tSquared, tCubed;
            var result_x, result_y;

            cx = 3.0 * (cp[1].x - cp[0].x);
            bx = 3.0 * (cp[2].x - cp[1].x) - cx;
            ax = cp[3].x - cp[0].x - cx - bx;
            cy = 3.0 * (cp[1].y - cp[0].y);
            by = 3.0 * (cp[2].y - cp[1].y) - cy;
            ay = cp[3].y - cp[0].y - cy - by;

            var t = dt * i
            tSquared = t * t;
            tCubed = tSquared * t;
            result_x = (ax * tCubed) + (bx * tSquared) + (cx * t) + cp[0].x;
            result_y = (ay * tCubed) + (by * tSquared) + (cy * t) + cp[0].y;
            curve[i] = {
                x: result_x,
                y: result_y
            };
        }

        var array = [];
        for (var i = 0; i < curve.length; i++) {
            try {
                var j = (i < 100) ? i : (199 - i);
                xx = parseInt(curve[j].x)
                yy = parseInt(Math.abs(100 - curve[j].y))
            } catch (e) {
                break
            }
            array.push([xx, yy])
        }
        return array
    }
    function randomSwipe(sx, sy, ex, ey) {
        // 设置随机滑动时长范围
        var timeMin = 500;
        var timeMax = 1000;
        // 设置控制点极限距离
        var leaveHeightLength = 50;
        var x2, y2, x3, y3; // 控制点坐标 
        // 根据起点和终点的相对位置计算控制点
        if (Math.abs(ex - sx) > Math.abs(ey - sy)) {
            var my = (sy + ey) / 2;


            y2 = my + random(0, leaveHeightLength);
            y3 = my - random(0, leaveHeightLength);

            var lx = (sx - ex) / 3;
            if (lx < 0) { lx = -lx; }
            x2 = sx + lx / 2 + random(0, lx);
            x3 = sx + lx + lx / 2 + random(0, lx);
        } else {
            var mx = (sx + ex) / 2;
            x2 = mx + random(0, leaveHeightLength);
            x3 = mx - random(0, leaveHeightLength);

            var ly = (sy - ey) / 3;
            if (ly < 0) { ly = -ly; }
            y2 = sy + ly / 2 + random(0, ly);
            y3 = sy - ly / 2 + random(0, ly);
        }

        // 确保控制点坐标有效
        if (x2 === undefined || y2 === undefined || x3 === undefined || y3 === undefined) {
            // log("控制点计算错误");
            return; // 退出函数
        }

        var time = [0, random(timeMin, timeMax)];
        var track = bezierCreate(sx, sy, x2, y2, x3, y3, ex, ey);

        // log("控制点A坐标:" + x2 + "," + y2);
        // log("控制点B坐标:" + x3 + "," + y3);
        // log("滑动时长:" + time[1]);

        gestures(time.concat(track));
    }
    randomSwipe(sx, sy, ex, ey)
}
Videos.prototype.返回 = function () {
    this.返回按钮.waitFor()
    sleep(1000)
    if (this.返回按钮.exists()) {
        click(this.返回按钮.findOne().bounds().centerX(), this.返回按钮.findOne().bounds().centerY());
        sleep(1000)
        log("返回")
    }
}
Videos.prototype.私信页返回 = function () {
    if (this.私信页返回按钮.exists()) {
        click(this.私信页返回按钮.findOne().bounds().centerX(), this.私信页返回按钮.findOne().bounds().centerY());
        // log("返回")
    }
}
Videos.prototype.slp = function (t) {
    if (t == null) {
        sleep(t + random(500, 1000))
    } else {
        sleep(t)
    }

}
Videos.prototype.放行性别用户 = function () {
    //性别要求
    if (this.sex != "不限" && this.data.user_sex != this.sex) {
        log('性别要求:', this.sex, '用户性别:', this.data.user_sex);
        return false
    }
    return true
}
Videos.prototype.放行年龄用户 = function () {
    if (this.data.user_age > 65 || this.data.user_age < this.age) {
        log('年龄要求:', this.age, '用户年龄:', this.data.user_age);
        return false
    }
    return true
}

// 判断用户回复时间是否符合要求
Videos.prototype.放行评论时间用户 = function (用户回复时间) {

    // 检查用户回复时间是否在 gold_time 列表中
    if (this.config.gold_time.some(time => 用户回复时间.includes(time))) {
        log("放行时间:", 用户回复时间);
        return true; // 包含在列表中，直接返回 true
    }

    // 如果不包含，提取具体日期并与当前日期比较
    const currentTime = new Date(); // 获取当前时间
    let replyDate;

    // 处理月-日格式
    if (/^\d{2}-\d{2}$/.test(用户回复时间)) {
        const [month, day] = 用户回复时间.split('-').map(Number);
        const year = currentTime.getFullYear(); // 使用当前年份
        replyDate = new Date(year, month - 1, day); // 创建日期对象
    }
    // 处理年-月-日格式
    else if (/^\d{4}-\d{2}-\d{2}$/.test(用户回复时间)) {
        replyDate = new Date(用户回复时间);
    }
    // 如果无法解析时间，返回 false
    else {
        return false;
    }

    // 计算时间差
    const timeDifference = currentTime - replyDate; // 毫秒
    const daysDifference = timeDifference / (1000 * 60 * 60 * 24); // 转换为天数
    return daysDifference <= 7; // 返回是否在7天内
}

Videos.prototype.放行用户区域 = function (user_city) {
    // 检查允许放行的区域列表
    if (this.city_in.length > 0) {
        // log("用户区域:", this.评论区用户回复地区)
        // 判断用户区域是否在允许放行的区域内
        const isAllowed = this.city_in.some(city => user_city.includes(city));
        if (isAllowed) {
            log("放行区域:", user_city)
            return true; // 用户区域被允许
        }
    }
    // 检查禁止放行的区域列表
    if (this.city_out.length > 0) {
        // 判断用户区域是否在禁止放行的区域内
        const isProhibited = this.city_out.some(city => user_city.includes(city));
        if (isProhibited) {
            log("禁止区域:", user_city)
            return false; // 用户区域不被允许
        }
    }

    // 如果用户区域不在放行区域和禁止区域中，默认不放行
    log("未知区域:", user_city);
    return false;
}


Videos.prototype.放行用户评论 = function (用户评论) {
    // 如果没有设置关键字，直接放行
    if (this.reply_keywords.length === 0) {
        // log("未设置关键字，放行所有用户评论");
        return true;
    }

    // 判断用户评论是否包含关键字
    const matchedKeywords = this.reply_keywords.filter(msg => 用户评论.includes(msg));

    if (matchedKeywords.length > 0) {
        log("用户评论包含关键字:", matchedKeywords.join(", ")); // 打印找到的关键字
        return true; // 用户评论被允许
    }

    log("用户评论未包含关键字");
    return false; // 用户评论不被允许
}


Videos.prototype.点赞 = function () {
    console.log("开始点赞");
    const currentTime = Date.now(); // 获取当前时间戳
    const oneMinute = this.config.like_time * 1000; // 点赞时间间隔，单位为秒

    waitTime = oneMinute - (currentTime - this.lastLikeTime)

    if (waitTime > 0) {
        console.log("等待点赞时间", waitTime);
        this.slp(waitTime)
    }
    this.heart++
    log("执行点赞操作")
    //this.评论区用户点赞.click(); // 点赞
    // 更新上次点赞时间
    this.lastLikeTime = currentTime;
    log("点赞成功！");

};


Videos.prototype.看作品 = function () {
    log("看作品")
    //观看用户主页作品
    if (textStartsWith("作品").exists() && text("橱窗").exists()) {
        log("回作品页")
        click("作品")
        this.slp(2000)
    }
    if (this.主页作品id.exists() && random(0, 3) == 1) {
        this.slp(3000)
        if (textStartsWith("作品").exists() && text("橱窗").exists()) {
            log("回作品页")
            click("作品")
            this.slp(2000)
        }

        click(this.主页作品id.findOne().bounds().centerX(), this.主页作品id.findOne().bounds().centerY())
        this.slp(3000)
        this.slp(this.获取视频时长())// 随机观看视频
        this.返回()
        this.主页用户昵称.waitFor()
        this.slp(1000)
    }
}
Videos.prototype.视频点赞 = function () {
    log("---开始执行视频点赞循环---")

    this.打开抖音()
    this.首页消息按钮text.waitFor();
    log("找到首页消息按钮")
    this.slp(3000)

    /*
    
    this.video_type = 0  //视频类型，0为默认，1为同城，2为搜索
    if (this.进入同城()) {
        log("进入同城")
        this.video_type = 1
    } else if (this.视频搜索()) {
        log("视频搜索")
        this.video_type = 2
    }
        
    */
    while (true) {
        this.heart++
        this.slp(3000)
        if (text("每日推荐歌曲").boundsInside(1, 1, x - 1, y - 1).exists()) {
            log("跳过汽水音乐广告")
            this.上滑()
            this.slp(3000)
            continue
        }
        if (!this.视频页关注加号.boundsInside(1, 1, x - 1, y - 1).exists()) {
            log("跳过好友视频")
            this.上滑()
            this.slp(3000)
            continue
        }
        try {
            this.视频主昵称 = this.视频主昵称id.boundsInside(1, 1, x - 1, y - 1).findOnce().text()
            log("视频主昵称:", this.视频主昵称)
            this.视频标题text = this.视频标题id.boundsInside(1, 1, x - 1, y - 1).findOnce().text()
            log("视频标题:", this.视频标题text)
            this.评论条数text = this.评论条数id.boundsInside(1, 1, x - 1, y - 1).findOnce().child(0).text()
            log("评论条数:", this.评论条数text)
            this.评论按钮 = this.评论按钮id.boundsInside(1, 1, x - 1, y - 1).findOnce()
            log("找到评论按钮")

        } catch (error) {
            log("视频信息获取失败，上滑")
            this.上滑()
            this.slp(3000)
            continue
        }
        if (this.视频主昵称 == null || this.视频标题text == null || this.评论条数text == null) {
            log("视频信息不完全，上滑")
            this.上滑()
            this.slp(3000)
            continue
        }
        if (this.临时列表.has(this.视频主昵称)) {
            log("已经处理过", this.视频主昵称)
            this.heart--
            this.上滑()
            this.slp(3000)
            continue
        }
        this.临时列表.add(this.视频主昵称)
        // log("下一个视频主昵称", this.下一个视频主昵称)
        let 提取评论数 = this.评论条数text.match(/\d+/); // 提取数字
        let 评论数 = 提取评论数 ? parseInt(提取评论数[0]) : 0;
        if (this.评论条数text.includes("万")) {
            评论数 *= 10000; // 将评论数乘以 10000
        }
        if (评论数 < this.config.talk_num) {
            log("评论数小于", this.config.talk_num, "跳过")
            this.上滑()
            this.slp(3000)
            continue
        }
        this.slp(2000)
        // 是否设置了关键词
        if (this.search_keywords.length > 0) {
            log('检测标题是否包含关键词');
            // 检查是否包含关键词
            let containsKeyword = this.search_keywords.some(keyword => this.视频标题text.includes(keyword));
            if (!containsKeyword) {
                log('视频不包含关键词，跳过');
                if (random(1, 10) == 1) {
                    js = 0
                    do {
                        log("长按屏幕");
                        if (longClick(500, 500)) {
                            js++
                            this.slp(3000)
                            if (text("分享给朋友").exists()) {
                                log("视频");
                                this.slp(2000)
                                click("不感兴趣")
                                this.slp(3000)
                                break
                            } else if (text("推荐给朋友").exists()) {
                                log("直播");
                                this.slp(3000)
                                back()
                                this.slp(2000)
                                this.上滑()
                                this.slp(3000)
                                js = 1
                                break
                            } else if (js == 2) {
                                this.slp(3000)
                                break
                            }
                        } else {
                            break
                        }
                        this.slp(3000)
                    } while (true)
                } else if (random(1, 10) > 6) {
                    this.slp(this.获取视频时长())// 随机观看视频
                    this.上滑()
                    this.slp(3000)
                } else {
                    this.上滑()
                    this.slp(3000)
                }
                continue
            }
        }
        this.slp(this.获取视频时长())// 随机观看视频
        log('打开评论区')
        this.评论按钮.parent().click()
        this.slp(2000)
        this.关闭评论区X.waitFor();
        this.slp(1000)
        // log("点击最大化")
        this.评论区最大化id.findOne().click()
        this.slp(3000)
        this.swipe_num = 0  //每个评论上滑次数
        while (true) {  //评论区循环逻辑
            this.heart++
            this.slp(3000)
            // 退出评论区条件，单个评论上滑次数超过最大次数，或者评论列表没有更多了
            if (text("暂时没有更多了").exists() || this.swipe_num > this.config.talk_swipe_num) {
                this.关闭评论();
                this.slp(2000)
                log("关闭评论")
                break;
            }

            if (this.评论区展开按钮id.exists() && this.评论区展开按钮id.findOne().text() == "展开") {
                this.评论区展开按钮id.click()
            }
            this.评论区坐标 = this.评论区id.findOne().bounds()
            this.评论 = this.评论id.find()
            // log("找到评论列表长度:", this.评论.length)

            this.swipe_num++

            // 遍历头像列表
            for (let i = 0; i < this.评论.length; i++) {  //评论区遍历
                this.slp(2000)
                this.heart++
                // log("评论列表:", i)
                try {
                    // this.评论坐标 = this.评论[i].bounds()
                    this.评论区用户昵称 = this.评论[i].findOne(this.评论区用户昵称id).text()
                    this.评论区用户回复时间 = this.评论[i].findOne(this.评论区用户时间id).text()
                    this.评论区用户回复地区 = (this.评论[i].findOne(this.评论区用户地区id).text().match(/[\u4e00-\u9fa5]+/g) || []).join('');
                    this.评论区用户评论 = this.评论[i].findOne(this.评论区用户评论id).text()
                    this.评论区用户点赞状态 = this.评论[i].findOne(this.评论区用户点赞状态id).desc()
                    this.评论区用户点赞 = this.评论[i].findOne(this.评论区用户点赞id)
                    this.评论区用户头像 = this.评论[i].findOne(this.评论区用户头像desc)
                } catch (error) {
                    continue
                }

                // 检查临时列表
                if (this.临时列表.has(this.评论区用户昵称)) {
                    log("用户昵称在临时列表中，跳过该用户");
                    continue;
                }

                // 检查用户点赞状态
                if (this.评论区用户点赞状态.endsWith(",已选中")) {
                    log("用户已点赞，跳过该用户");
                    continue;
                }

                // 检查用户区域
                if (!this.放行用户区域(this.评论区用户回复地区)) {
                    log("用户回复地区不在放行区域，跳过该用户");
                    continue; // 跳过该用户
                }

                // 检查评论时间
                if (!this.放行评论时间用户(this.评论区用户回复时间)) {
                    log("用户回复时间太早，跳过该用户");
                    continue;
                }
                // 检查用户评论
                if (!this.放行用户评论(this.评论区用户评论)) {
                    continue;
                }
                this.临时列表.add(this.评论区用户昵称);
                log("找到目标用户:", this.评论区用户昵称)
                // 检查本轮是否已经点过赞
                this.slp(2000)
                try {
                    click(this.评论区用户头像.bounds().centerX(), this.评论区用户头像.bounds().centerY())
                    this.slp(2000)
                    if (!this.主页用户昵称.exists()) {
                        log("点击评论头像失败")
                        continue
                    }
                } catch (error) {
                    log("没找到评论头像")
                    continue
                }
                this.主页用户昵称.waitFor()
                this.slp(1000)
                try {
                    this.收集用户数据(); // 收集用户数据
                } catch (error) {
                    log("收集用户数据失败")
                    continue
                }
                this.slp(1000)
                this.看作品()
                log("这里是看作品1次返回")
                this.slp(2000)
                this.返回()
                log("这里是看作品2次返回")
                this.slp(2000)
                text(this.data.user_name).waitFor();
                this.slp(1000)
                if (!this.放行性别用户() || !this.放行年龄用户()) {
                    log("用户不符合所有要求，跳过");
                    continue
                }
                log("用户符合所有要求=====");
                this.slp(3000)
                //如果点赞超过最大次数，或者本轮点赞超过限制则退出
                this.当前评论赞数量 = this.查询手机数据()[0].评论赞数量
                if (this.当前评论赞数量 > this.config.day_gold_max_num) {
                    device.setBrightness(this.config.close_Brightness)
                    return
                }
                this.当前评论赞数量++
                try {
                    log("==========================")
                    this.点赞()
                    this.swipe_num--
                    log("==========================")
                    this.phone_data = {
                        "IMEI": this.IMEI,
                        "访问时间": this.获取时间(),
                        "评论赞数量": this.当前评论赞数量
                    };
                    this.更新手机数据(this.phone_data);
                    this.上一轮评论区点赞的用户昵称 = this.评论区用户昵称
                    log("总点赞次数--------:" + this.当前评论赞数量)
                    this.slp(1000 * random(3, 7))
                } catch (error) {
                    log("点赞失败")
                }
            }

            log("上滑次数:", this.swipe_num)
            this.上滑()
            this.slp(3000)
        }



        /************* 检测是否点赞成功 **********************
        while (!this.下一个视频主昵称.exists()) {
            this.slp(3000)
            this.上滑()
            this.slp(3000)
        }
        while (!this.视频主昵称.exists()) {
            this.slp(3000)
            this.下滑()
            this.slp(3000)
        }
        this.评论按钮.parent().click()
        this.slp(2000)
        this.关闭评论区X.waitFor();
        this.slp(1000)
        this.评论区最大化id.findOne().click()
        this.slp(3000)
        if (this.评论区展开按钮id.exists() && this.评论区展开按钮id.findOne().text() == "展开") {
            this.评论区展开按钮id.click()
        }
        this.评论区坐标 = this.评论区id.findOne().bounds()
        this.评论 = this.评论id.find()
        for (let i = 0; i < this.评论.length; i++) {
            try {
                // this.评论坐标 = this.评论[i].bounds()
                this.评论区用户昵称 = this.评论[i].findOne(this.评论区用户昵称id).text()
                this.评论区用户点赞状态 = this.评论[i].findOne(this.评论区用户点赞状态id).desc()
                // 检查用户点赞状态
                if (this.上一轮评论区点赞的用户昵称 == this.评论区用户昵称 && this.评论区用户点赞状态.endsWith(",已选中")) {
                    log("点赞成功");
                } else {
                    log("点赞丢失");
                    // 设置1小时的最大时间
                    const maxTime = 1000 * 60 * this.config.gold_pause_time; // 单位为分钟
                    const interval = 5000; // 每5秒增加1
                    // 启动计时器
                    const intervalId = setInterval(() => {
                        this.heart++; // 每5秒计数器加1
                        // log("点赞丢失计数器增加:", this.heart);
                    }, interval);
                    // 设置超时停止计数器
                    setTimeout(() => {
                        clearInterval(intervalId); // 停止计数器
                        log("暂停结束，继续执行");
                    }, maxTime);
                }
            } catch (error) {
                i--
                log("检查点赞状态失败");
                this.slp(5000)
            }
        }

        /*******************检测结束*****************/

        this.slp(3000)
    }
}
Videos.prototype.取关用户 = function () {
    this.打开抖音()
    if (!this.首页我按钮desc.exists()) {
        return
    }
    click(this.首页我按钮desc.findOne().bounds().centerX(), this.首页我按钮desc.findOne().bounds().centerY())
    this.主页我的钱包text.waitFor();
    this.slp(1000)
    this.主页关注.findOne().parent().click()
    textContains("我的关注").waitFor();
    this.slp(1000)
    if (text("综合排序").exists()) {
        text("综合排序").parent().click()
        text("最早关注").waitFor();
        this.slp(1000)
        click("最早关注")
        this.slp(1000)
    }
    for (let i = 0; i < text("已关注").find().length; i++) {
        this.slp(1000)
        click("已关注", i)
        this.slp(1000)
    }
    for (let i = 0; i < text("互相关注").find().length; i++) {
        click("互相关注")
        this.slp(1000)
        text("取消关注").waitFor()
        this.slp(1000)
        click("取消关注")
        this.slp(1000)
    }
}
Videos.prototype.批量发送私信 = function () {
    this.打开抖音()
    if (!this.首页我按钮desc.exists()) {
        return
    }
    click(this.首页我按钮desc.findOne().bounds().centerX(), this.首页我按钮desc.findOne().bounds().centerY())
    this.主页我的钱包text.waitFor();
    this.slp(3000)
    this.主页粉丝text.findOne().parent().click()
    textContains("我的粉丝").waitFor();
    this.slp(3000)
    this.主页粉丝页粉丝头像列表 = this.主页粉丝页粉丝头像.boundsInside(0, 0, x / 2, y).find()
    for (let i = 0; i < this.主页粉丝页粉丝头像列表.length; i++) {
        this.主页粉丝页粉丝昵称 = this.主页粉丝页粉丝头像列表[i].parent().parent().child(1).child(0).child(0).text()
        this.主页粉丝页粉丝关注按钮 = this.主页粉丝页粉丝头像列表[i].parent().parent().child(2).child(0).child(0).desc()
        this.主页粉丝页粉丝三个点 = this.主页粉丝页粉丝头像列表[i].parent().parent().child(2).child(1).child(0).desc()
        // log(this.主页粉丝页粉丝昵称 + "-" + this.主页粉丝页粉丝关注按钮 + "-" + this.主页粉丝页粉丝三个点)
        if (this.主页粉丝页粉丝关注按钮 != "互相关注") {
            this.slp(3000)
            continue
        }
        this.主页粉丝页粉丝头像列表[i].click()
        this.主页用户昵称.waitFor()
        this.slp(1000)
        this.收集用户数据()
        this.看作品()
        log("查询用户ID:", this.data.user_id);
        let userExists = this.查询用户数据(this.data.user_id)
        if (userExists) {
            log('用户已在库中，跳过私信。');
            continue;
        }
        if (!this.放行用户区域(this.data.user_ip) || !this.放行年龄用户() || !this.放行性别用户() || !text("私信").exists()) {
            this.返回()
            this.slp(3000)
            continue
        }
        this.slp(3000)
        desc("私信").findOne().click()
        this.slp(3000)
        setText(this.config.message[random(0, this.config.message - 1)])
        this.slp(1000)
        //desc("发送").click()
        this.slp(1000)
        this.写入数据(this.user_apiUrl, this.data)
        this.slp(3000)
        this.返回()
        this.主页用户昵称.waitFor()
        this.slp(1000)
        this.返回()
        this.slp(3000)
        this.slp(3000)
        this.slp(3000)
        this.slp(3000)
    }
}
Videos.prototype.消息页回关加私信 = function () {
    if (this.phone.length === 0) {
        log("未配置私信")
        return
    }
    this.打开抖音()
    if (this.首页消息按钮id = null) {
        this.首页消息按钮id = id(text("消息").findOne().id())
    }
    if (!this.消息页顶部心id.exists() && this.评论图标id.exists()) {
        click("消息")
    }
    this.消息页顶部心id.waitFor();
    this.slp(1000)
    while (true) {
        for (let i = 0; i < this.消息页粉丝信息数量.find().length; i++) {
            this.heart++
            this.消息页粉丝信息数量.find()[i].parent().parent().parent().click()
            this.slp(1000)
            this.私信页顶部头像.waitFor()
            this.slp(1000)
            this.私信页顶部头像.findOne().click()
            this.收集用户数据()
            if (this.查询用户数据(this.data.user_id) || this.放行用户区域(this.data.user_ip) || !this.放行年龄用户() || !this.放行性别用户()) {
                this.返回()
                this.slp(3000)
                this.返回()
                this.slp(3000)
                continue
            }
            this.slp(3000)
            this.看作品()
            this.slp(3000)
            if (this.about_friends && text("回关").exists()) {
                text("回关").findOne().click()
                this.slp(3000)
            }
            this.返回()
            this.slp(2000)
            this.私信页发消息()
            this.slp(2000)
        }
        this.slp(3000)
        this.上滑()
        if (!this.消息页粉丝信息数量.find().length) { break }
        this.slp(3000)
    }
    if (!this.about_friends) {
        log("未配置回关数量")
        return
    }
    while (!this.消息页新朋友text.exists()) {
        this.下滑()
        this.slp(1000)
    }
    click("新朋友", 0)   //消息页新朋友，进入新朋友页面
    this.slp(2000)
    if (this.消息页新朋友页头像id.find().length == 0) { return }
    this.slp(2000)
    while (true) {
        this.新朋友列表 = text("回关").find()
        if (!this.新朋友列表.length) { break }
        a = this.新朋友列表.slice(0, this.about_friends)
        for (let i = 0; i < a.length; i++) {
            this.heart++
            try {
                log(a[i].parent().parent().parent().child(1).child(0).text()) //获取昵称
                a[i].parent().parent().parent().parent().click() //点击进入用户主页    
            } catch (error) {
                continue
            }
            this.slp(3000)
            this.收集用户数据()
            if (this.查询用户数据(this.data.user_id) || !this.放行用户区域(this.data.user_ip) || !this.放行年龄用户() || !this.放行性别用户()) {
                this.返回()
                this.slp(3000)
                continue
            }
            this.slp(3000)
            this.看作品()
            this.slp(3000)
            if (this.about_friends) {
                text("回关").findOne().click()
                this.slp(2000)
            }
            desc("私信").findOne().click()
            this.slp(3000)
            this.私信页发消息()
            this.写入数据(this.user_apiUrl, this.data)
            this.主页用户昵称.waitFor()
            this.slp(1000)
            this.返回()
            this.slp(3000)
        }
        this.上滑()
        this.slp(3000)
    }
}
Videos.prototype.私信页发消息 = function () {
    this.user_msg = this.用户私信内容();
    if (this.user_msg) {
        if (this.config.deepseek.work) {
            this.ai(this.user_msg, "deepseek", "deepseek-chat").then(result => {
                if (result === false) {
                    console.log("助手回复失败");
                    this.slp(2000);
                    this.私信页返回();
                    this.slp(3000);
                    return;
                } else {
                    setText(result);
                }
            });
        } else if (this.config.nengyong.work) {
            this.ai(this.user_msg, "nengyong", "gpt-4o-mini").then(result => {
                if (result === false) {
                    console.log("助手回复失败");
                    this.slp(2000);
                    this.私信页返回();
                    this.slp(3000);
                    return;
                } else {
                    setText(result);
                }
            });
        }
        this.slp(2000);
        //desc("发送").click();
        this.slp(2000);

        //发送定义好的联系方式内容
        for (let i = 0; i < this.phone.length; i++) {
            setText(this.phone[i]);
            this.slp(2000);
            desc("发送").click();
            this.slp(2000);
        }

    }
    this.slp(2000);
    this.私信页返回();
    this.slp(3000);
}
Videos.prototype.用户私信内容 = function () {
    //提取私信页面的私信内容并返回
    this.用户私信内容id = id("aof").find()
    for (let i = 0; i < this.用户私信内容id.length; i++) {
        try {
            this.msg = this.用户私信内容id[i].parent().child(2).child(1).child(0).child(0).child(0).child(0).child(0).text();
        } catch (error) {
            this.msg = ""
        }

        // 如果 msgs 不为空，添加逗号分隔符
        if (this.msgs) {
            this.msgs += ","; // 添加逗号
        }

        this.msgs += this.msg
    }
    return this.msgs
}
Videos.prototype.ai = function (userMessage, serviceName, model) {
    return new Promise((resolve, reject) => {
        // 将用户消息添加到对话历史
        this.conversationHistory.push({ role: "user", content: userMessage });

        // 保留最近的 3 条用户消息和 3 条助手消息
        if (this.conversationHistory.length > 6) {
            this.conversationHistory = this.conversationHistory.slice(-6);
        }

        // 手动构建请求体
        const messages = [{ role: "system", content: this.config.contexts.join("\n") }]
            .concat(this.conversationHistory);

        // 定义请求体
        const requestBody = {
            model: model,
            messages: messages
        };

        // 定义请求选项
        const options = {
            method: "POST",
            headers: {
                "Content-Type": "application/json",
                "Authorization": `Bearer ${this.config[serviceName].apiKey}`
            },
            body: JSON.stringify(requestBody)
        };

        // 发送 HTTP 请求
        http.request(this.config[serviceName].url, options, function (response) {
            if (response.statusCode === 200) {
                try {
                    const responseBody = response.body.string();
                    const jsonResponse = JSON.parse(responseBody);
                    const assistantReply = jsonResponse.choices[0].message.content;

                    if (assistantReply) {
                        console.log("助手的回复:", assistantReply);
                        this.conversationHistory.push({ role: "assistant", content: assistantReply });
                        resolve(assistantReply); // 成功获取到助手的回复，返回回复内容
                    } else {
                        console.log("没有获取到助手的回复");
                        resolve(false); // 返回 false
                    }
                } catch (error) {
                    console.error("解析响应时出错:", error);
                    resolve(false); // 返回 false
                }
            } else {
                console.log("请求失败，状态码:", response.statusCode);
                resolve(false); // 返回 false
            }
        }.bind(this));
    });
}
Videos.prototype.进入同城 = function () {
    if (this.city_set === "") {
        // log("未配置同城")
        return
    }
    this.同城 = this.city_set + "，按钮"
    if (desc(this.同城).exists()) {
        desc(this.同城).click();
        this.slp(3000)
        this.上滑()
    }
}
Videos.prototype.视频搜索 = function () {
    // 检查搜索开关和关键字列表是否有效
    if (this.search_keywords.length === 0) {
        log("搜索内容未配置");
        return;
    }
    keyword = this.search_keywords[random(0, this.search_keywords.length - 1)]; // 获取关键字
    // 移除已搜索的关键字
    const index = this.search_temp.indexOf(keyword); // 查找关键字的索引
    if (index === -1) {
        log("视频搜索关键字:", keyword)
        this.主页搜索按钮desc.waitFor()
        this.slp(1000)
        log("搜索按钮存在")
        this.主页搜索按钮desc.findOne().click()
        log("点击搜索按钮")
        this.slp(3000)
        this.搜索按钮text.waitFor()
        log("等待搜索")
        this.slp(1000)
        setText(keyword)
        click(this.搜索按钮text.findOne().bounds().centerX(), this.搜索按钮text.findOne().bounds().centerY())
        this.slp(2000)
        click(this.搜索页视频按钮text.findOne().bounds().centerX(), this.搜索页视频按钮text.findOne().bounds().centerY())
        this.slp(5000)
        click(x / 4, y / 2)
        log("点击第1个视频")
        this.slp(3000)
        log("搜索完成")
        this.search_temp.push(keyword); // 将关键字添加到已搜索列表
    }
}
Videos.prototype.退出检测 = function () {
    if (this.exitCheckStarted) {
        log("退出检测已经启动，跳过...");
        return;
    }
    this.exitCheckStarted = true; // 在启动线程之前设置
    const self = this; // 保存当前上下文
    threads.start(function () {
        function checkExit() {
            try {
                self.config = self.下载配置文件(); // 使用 self 访问 Videos 实例
                if (self.config.exit_app) {
                    self.slp(3000);
                    log("检测程序退出指令，结束程序");
                    if (self.jk) {
                        self.jk.interrupt();
                    }
                    if (self.xfc) {
                        self.xfc.interrupt();
                    }
                    if (self.heartID) {
                        self.heartID.interrupt();
                    }
                    exit();
                }
            } catch (error) {
                log("检查退出时发生错误: " + error.message);
            }
        };

        // 每分钟检测一次
        setInterval(() => {
            checkExit();
        }, 1000 * 60);
    });
};

// 检测是否结束程序
Videos.prototype.退出检测1 = function () {
    // 定义一个标志位，跟踪是否已经启动退出检测
    if (this.exitCheckStarted) {
        log("退出检测已经启动，跳过...");
        return; // 如果已经启动，直接返回
    }

    // 设置标志位为 true，表示退出检测已启动
    this.exitCheckStarted = true;

    const checkExit = () => {
        this.config = this.下载配置文件(); // 下载配置文件
        if (this.config.exit_app) {
            this.slp(3000);
            log("检测程序退出指令，结束程序");
            if (this.jk) {
                this.jk.interrupt();
            }
            if (this.xfc) {
                this.xfc.interrupt();
            }
            if (this.heartID) {
                this.heartID.interrupt();
            }
            exit();
        }
    };

    // 每分钟检测一次
    setInterval(() => {
        checkExit();
    }, 1000 * 60); // 60000毫秒 = 1分钟
};


Videos.prototype.启动 = function () {
    const PEAK_TIMES = [
        { start: 0, end: 1 },
        { start: 6, end: 11 },
        { start: 11, end: 15 },
        { start: 15, end: 24 }
    ];


    // 检查当前时间是否在工作时间段
    const checkTime = () => {
        const now = new Date();
        const currentHour = now.getHours();
        // log("判断工作时间段");
        return PEAK_TIMES.some(peak => currentHour >= peak.start && currentHour < peak.end)
    };


    // 检查评论赞数量
    const checkGoldNum = () => {
        this.当前评论赞数量 = this.查询手机数据()[0].评论赞数量;
        if (this.当前评论赞数量 > this.config.day_gold_max_num) {
            log("点赞上限");
            if (this.heartID) {
                this.heartID.interrupt(); // 停止当前线程
                this.heartID = null; // 清除主线程引用
            }

            return true;
        }
    };

    // 检测卡死
    const checkStuck = () => {
        log("上次心跳值：", this.lodHeart, "当前心跳值：", this.heart);
        if (this.lodHeart !== -1 && this.heart === this.lodHeart) {
            log("程序卡死");
            if (this.heartID) {
                this.heartID.interrupt(); // 停止当前线程
                this.heartID = null; // 清除主线程引用
            }
            return true;
        } else {
            this.lodHeart = this.heart;
        }
    };

    // 检测验证弹窗
    const checkYz = () => {
        if (text("开始检测").exists()) {
            log("弹出验证窗");
            if (this.jk) {
                this.jk.interrupt();
                this.jk = null;
            }
            if (this.heartID) {
                this.heartID.interrupt(); // 停止当前线程
                this.heartID = null; // 清除主线程引用
            }
            return true;
        }
    };

    // 检测程序退出
    const checkExit = () => {
        this.config = this.下载配置文件();
        if (this.config.exit_app) {
            log("退出程序");
            if (this.jk) {
                this.jk.interrupt();
                this.jk = null;
            }
            if (this.xfc) {
                this.xfc.interrupt();
                this.xfc = null;
            }
            if (this.heartID) {
                this.heartID.interrupt();
                this.heartID = null;
            }
            exit();
        }
    };

    // 启动悬浮窗线程
    const startXfc = () => {
        if (this.config.xfc && !this.xfc) {
            log("启动悬浮窗");
            this.xfc = threads.start(() => { this.悬浮窗(); });
            return true;
        }
    };

    // 启动监控线程
    const startJk = () => {
        if (!this.jk) {
            log("启动监控");
            this.jk = threads.start(() => { this.监控(); });
            return true;
        }
    };

    // 启动主程序
    const startMain = () => {
        if (!this.heartID) {
            log("启动主程序");
            this.heartID = threads.start(() => { this.主程序(); });
            return true;
        }
    };
    log("主程序启动")
    const main = () => {
        this.sleep_time = 60
        checkExit()
        checkStuck()
        if (!checkTime()) {
            this.sleep_time = 60 * 5
        }
        if (checkGoldNum()) {
            const now = new Date();
            const nextDay = new Date(now.getFullYear(), now.getMonth(), now.getDate() + 1);
            this.sleep_time = nextDay - now;
        }
        if (checkYz()) {
            this.sleep_time = 60 * 60
        }
        startXfc()
        startJk()
        startMain()
        setTimeout(main, this.sleep_time * 1000);
    }
    main()
};



Videos.prototype.主程序 = function () {
    this.视频点赞()
    this.消息页回关加私信()
    this.清理缓存()
}





//创建 Videos 的实例
var v = new Videos()

log("启动")

v.启动();
